package org.TCC_NOVO.server;

import br.univali.celine.lms.integration.ContentPackageBuilder;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import java.io.File;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.TCC_NOVO.client.modelo.Atividade;
import org.TCC_NOVO.client.modelo.Atividade_Roteiro;
import org.TCC_NOVO.client.modelo.Avaliacao;
import org.TCC_NOVO.client.modelo.Conteudo;
import org.TCC_NOVO.client.GWTService;
import org.TCC_NOVO.client.modelo.Objetivo;
import org.TCC_NOVO.client.modelo.OcorrenciaTarefa;
import org.TCC_NOVO.client.modelo.OcorrenciaUnidade;
import org.TCC_NOVO.client.modelo.Papel;
import org.TCC_NOVO.client.modelo.Projeto;
import org.TCC_NOVO.client.modelo.Roteiro;
import org.TCC_NOVO.client.modelo.Slide;
import org.TCC_NOVO.client.modelo.TipoAvaliacao;
import org.TCC_NOVO.client.modelo.Unidade;
import org.TCC_NOVO.client.modelo.Usuario;
import org.TCC_NOVO.dao.JPADAOFactory;
import org.TCC_NOVO.dao.JPADAOPapel;
import org.TCC_NOVO.dao.JPADAOUsuario;
import org.TCC_NOVO.dao.JPAUtil;

/** testando commit **/
public class GWTServiceImpl extends RemoteServiceServlet implements GWTService {

     private Connection conn;
    private final JPADAOFactory daoFac;

    public GWTServiceImpl() throws Exception {
        JPAUtil.inicializar("lomanPU");
        daoFac = JPADAOFactory.getInstance();
    }

    //Método para Estabelecer a Conexão com o Banco de Dados...
    @Override
     public boolean Conexao(String odbc) {
         boolean bConect = false;
         try {
            //Abaixo é para fazer a conexão com o FIREBIRD
            /*Class.forName("org.firebirdsql.jdbc.FBDriver");
            conn = DriverManager.getConnection(
               odbc,
               "sysdba",
               "masterkey");

            stmt = conn.createStatement();
            bConect = true;
            */

            //Abaixo é para fazer a conexão com o MySQL
             String url = "jdbc:mysql://localhost:3306/oas";
             //String url = "jdbc:mysql://localhost:3306/dbmy_81490";
             String user = "root";
             //String user = "DBMY_81490";
             String pass = "root";
             //String pass = "so93cvke";

             try {
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection(url, user, pass);
                //stmt = conn.createStatement();
                bConect = true;
            } catch (ClassNotFoundException e) {
                System.out.println("Problemas na Conexão! Verifique.");
             }

         } catch (Exception e) {
            System.out.println("Não foi possível conectar ao banco: " + e.getMessage());
         }

     return bConect;
   }

    //Método para efetuar o Login do Usuario no Sistema...
   @Override
    public String efetuaLogin(String nick, String senha) {

       String sNomeUsua = "";
       try {
            JPADAOUsuario daoUsuario = daoFac.getDAOUsuario();
            Usuario usuario = daoUsuario.buscarLogin(nick, senha);
            sNomeUsua = usuario.getId() + "," + usuario.getNome() + "," + usuario.getPapel().getNome();
        } catch (Exception ex) {
            Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            }
        return sNomeUsua;
    }

    //Método implementado para retornar Dados do Usuario...
    @Override
    public List<Usuario> retornarDadosUsuarios(String papel) {

        List<Usuario> usuarios = new ArrayList<Usuario>();
        try {
            JPADAOUsuario daoUsu = daoFac.getDAOUsuario();
            List<Usuario> l = daoUsu.listarTodos();
            if (papel == null)
                usuarios = l;
            else
                for (Usuario u:l) {
                    if (u.getPapel().getNome().equals(papel))
                        usuarios.add(u);
               }
        } catch (Exception ex) {
            Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
           }

        return usuarios;
       }

    @Override
    public void salvarUsuario(Usuario usuario) {

        try {
            JPADAOUsuario daoUsu = daoFac.getDAOUsuario();
            daoUsu.gravar(usuario);
        } catch (Exception ex) {
            Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
   }

           }

    @Override
    public void excluirUsuario(String nick) {

        try {
            JPADAOUsuario daoUsu = daoFac.getDAOUsuario();
            daoUsu.excluir(daoUsu.buscarPeloNick(nick));
        } catch (Exception ex) {
            Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
       }

   }

    @Override
    public List<Papel> retornarDadosPapeis() {
        List<Papel> papeis = null;
        try {
            JPADAOPapel daoPap = daoFac.getDAOPapel();
            papeis = daoPap.listarTodos();

        } catch (Exception ex) {
            Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
        return papeis;
    }

    //Método implementado para retornar Dados do Usuario das tarefas...
    public ArrayList<Usuario> RetornarDadosUsuarioTarefas(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<Usuario> usuarios = new ArrayList();
        try {
           Statement stmt = conn.createStatement();
           rs = stmt.executeQuery(Query);
            while (rs.next()) {
               Usuario usua = new Usuario();
                usua.setId(rs.getInt("ID"));
               usua.setNome(rs.getString("Nome"));
                usua.setNick("[" + rs.getString("Papel").substring(0, 1) + "] " + rs.getString("Nick"));
               usua.setEmail(rs.getString("Email"));
                //usua.setPapel(rs.getString("Papel"));
               usuarios.add(usua);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return usuarios;
   }

    //Método Implementado para fazer a inclusão dos registro...
    public int IncluirRegistro(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs;
       String sSQL = Query;
       String sTabela = "";
       int ID = 0;
        try {
           Statement stmt = conn.createStatement();
           stmt.execute(sSQL);
           //feito para retornar o ID que acabou de ser incluido
           sTabela = sSQL.substring(12, sSQL.indexOf('('));
            sSQL = "select Max(ID) ID from " + sTabela;
           rs = stmt.executeQuery(sSQL);
            while (rs.next()) {
               ID = rs.getInt("ID");
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return ID;
   }

    //Método Implementado para fazer a exclusao dos registro...
    public void ExcluirRegistro(String Query) {
       Query = Query.toUpperCase();
        try {
           Statement stmt = conn.createStatement();
           stmt.execute(Query);
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    //Método Implementado para fazer a alteraçao dos registro...
    @Override
    public void EditarRegistro(String Query) {
       Query = Query.toUpperCase();
        try {
           Statement stmt = conn.createStatement();
           stmt.execute(Query);
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    //Método implementado para retornar Dados do papelUsuario...
   /*public ArrayList<PapelUsuario> RetornarPapelUsuarios(String Query){
       ResultSet rs = null;
       ArrayList<PapelUsuario> ArrayPapelUsua = new ArrayList();
       try{
           rs = stmt.executeQuery(Query);
           while (rs.next()){
               PapelUsuario papUsua = new PapelUsuario();
               papUsua.setNick(rs.getString("Nick"));
               papUsua.setPapel(rs.getString("Papel"));
               ArrayPapelUsua.add(papUsua);
           }
           rs.close();
       } catch(SQLException e){
           System.err.println("SQLException: " + e.getMessage());
       }
       return ArrayPapelUsua;
   }

    //Método implementado para retornar Dados do papelUsuario...
   public void IncluirPapelUsuarios(ArrayList<PapelUsuario> array){
       ResultSet rs = null;
       try{
           for (int y=0; y < array.size(); y++) {
               String sSQL = "select C.ID ID_Usua, B.ID ID_Pap "+
                              "from papel_usuario A "+
                              "inner join papeis B on B.ID = A.idf_papeis "+
                              "inner join usuario C on C.ID = A.idf_usuario "+
                              "where C.Nick = "+array.get(y).getNick();
                rs = stmt.executeQuery("select ");
           }

           rs = stmt.executeQuery("");
           while (rs.next()){
               PapelUsuario papUsua = new PapelUsuario();
               papUsua.setNick(rs.getString("Nick"));
               papUsua.setPapel(rs.getString("Papel"));
               //ArrayPapelUsua.add(papUsua);
           }
           rs.close();
       } catch(SQLException e){
           System.err.println("SQLException: " + e.getMessage());
       }
   }
*/
    //Método implementado para retornar Dados do Projeto...
   @Override
    public ArrayList<Projeto> RetornarDadosProjeto(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<Projeto> projetos = new ArrayList();
        try {
           Statement stmtProj = conn.createStatement();
           rs = stmtProj.executeQuery(Query);
            while (rs.next()) {
               Projeto proj = new Projeto();
               proj.setID(rs.getInt("ID"));
               proj.setNome(rs.getString("Nome"));
               proj.setAssunto(rs.getString("Assunto"));
               proj.setUsuarioResp(rs.getString("Nick_Usuario"));
               proj.setConteudista(rs.getString("Nick_Conteud"));
               proj.setDataIni(rs.getDate("Data_Inicio"));
               proj.setDataEnt(rs.getDate("Data_Entrega"));
               //proj.setDataIni(rs.getDate("Data_Inicio"));
               //proj.setDataEnt(rs.getDate("Data_Entrega"));
               proj.setObserv(rs.getString("Observacoes"));
               projetos.add(proj);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return projetos;
   }

    //Método implementado para retornar Dados da Matriz...
    public ArrayList<Unidade> RetornarDadosMatriz(String Query) {
       Query = Query.toUpperCase();
       String sSQL = "";
       String sIDUnid = "";
       ResultSet rsUnidade = null;
       ResultSet rsObjetivo = null;
       ResultSet rsConteudo = null;
       ResultSet rsAtividade = null;
       ResultSet rsAvaliacao = null;
       ArrayList<Unidade> unidades = new ArrayList();
       ArrayList<Objetivo> objetivos;
       ArrayList<Conteudo> conteudos;
       ArrayList<Atividade> atividades;
       ArrayList<Avaliacao> Avaliacoes;
        try {
           Statement stmtUnid = conn.createStatement();
           Statement stmtObj = conn.createStatement();
           Statement stmtCont = conn.createStatement();
           Statement stmtAtiv = conn.createStatement();
           Statement stmtAval = conn.createStatement();

           rsUnidade = stmtUnid.executeQuery(Query);
            while (rsUnidade.next()) {
               objetivos = new ArrayList();
               conteudos = new ArrayList();
               atividades = new ArrayList();
               Avaliacoes = new ArrayList();

               sIDUnid = rsUnidade.getString("ID");

               Unidade unid = new Unidade();
               unid.setID(rsUnidade.getInt("ID"));
               unid.setNome(rsUnidade.getString("Nome"));
               unid.setDescricao(rsUnidade.getString("Descricao"));
               unid.setDuracao(rsUnidade.getString("Duracao"));
               unid.setStatus(rsUnidade.getString("Status"));

                //iteraçao para retornar e adicionar na lista os objetivos
                sSQL = "select * from OBJETIVO where IDF_UNIDADE = " + sIDUnid;
               rsObjetivo = stmtObj.executeQuery(sSQL);
                while (rsObjetivo.next()) {
                   Objetivo Obj = new Objetivo();
                   Obj.setId(rsObjetivo.getInt("ID"));
                   Obj.setDescricao(rsObjetivo.getString("Descricao"));
                   objetivos.add(Obj);
               }
               unid.setArrayObjetivo(objetivos);

                //iteraçao para retornar e adicionar na lista os conteudos
                sSQL = "select * from CONTEUDO where IDF_UNIDADE = " + sIDUnid;
               rsConteudo = stmtCont.executeQuery(sSQL);
                while (rsConteudo.next()) {
                   Conteudo Cont = new Conteudo();
                   Cont.setId(rsConteudo.getInt("ID"));
                   Cont.setDescricao(rsConteudo.getString("Descricao"));
                   conteudos.add(Cont);
               }
               unid.setArrayConteudo(conteudos);

                //iteraçao para retornar e adicionar na lista as atividades
                sSQL = "select * from ATIVIDADE where IDF_UNIDADE = " + sIDUnid;
               rsAtividade = stmtAtiv.executeQuery(sSQL);
                while (rsAtividade.next()) {
                   Atividade Ativ = new Atividade();
                   Ativ.setId(rsAtividade.getInt("ID"));
                   Ativ.setDescricao(rsAtividade.getString("Descricao"));
                   atividades.add(Ativ);
               }
               unid.setArrayAtividade(atividades);

                //iteraçao para retornar e adicionar na lista as avaliações
                sSQL = "select * from AVALIACAO A inner join TIPO_AVALIACAO B on B.ID = A.IDF_TIPO_AVALIACAO where A.IDF_UNIDADE = " + sIDUnid;
               rsAvaliacao = stmtAval.executeQuery(sSQL);
                while (rsAvaliacao.next()) {
                   Avaliacao Aval = new Avaliacao();
                   Aval.setId(rsAvaliacao.getInt("ID"));
                   Aval.setTipo(rsAvaliacao.getString("Tipo"));
                   Aval.setDescricao(rsAvaliacao.getString("Descricao"));
                   Avaliacoes.add(Aval);
               }
               unid.setArrayAvaliacao(Avaliacoes);

               unidades.add(unid);
           }
           rsUnidade.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return unidades;
   }

   //Método implementado para retornar Dados do Roteiro...
   public Roteiro RetornarDadosRoteiro(int codigoUnidade){
       String sSQL = "";
       ResultSet rsItens = null;
       HashMap<Integer, Slide> slideRoteiros;
       Roteiro rot = new Roteiro();
       try{
           Statement stmtItens = conn.createStatement();
           slideRoteiros = new HashMap<Integer, Slide>();

           sSQL = "select * from slide s where s.cd_unidade = "+codigoUnidade;
           rsItens = stmtItens.executeQuery(sSQL);
           while (rsItens.next()){
               Slide slide = new Slide();
               slide.setId(rsItens.getInt("cd_slide"));
               slide.setReferencia(rsItens.getString("ds_referencia"));
               slide.setConteudo(rsItens.getString("ds_conteudo"));
               slide.setComentario(rsItens.getString("ds_comentario"));
               slide.setIdf_Unid(rsItens.getInt("cd_unidade"));
               rot.addSlide(slide);
               slideRoteiros.put(slide.getId(), slide);
           }
           rsItens.close();
           
           //iteração para retornar e adicionar na lista as atividades
           sSQL = "select * from ATIVIDADE_ROTEIRO A inner join USUARIO B on B.ID = A.IDF_RESP where A.IDF_UNIDADE = "+codigoUnidade;
           rsItens = stmtItens.executeQuery(sSQL);
           while (rsItens.next()){
               Atividade_Roteiro AtivRot = new Atividade_Roteiro();
               AtivRot.setId(rsItens.getInt("ID"));
               AtivRot.setIdf_unidade(rsItens.getInt("IDF_UNIDADE"));
               AtivRot.setTitulo(rsItens.getString("Titulo"));
               AtivRot.setDescricao(rsItens.getString("Descricao"));
               SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
               AtivRot.setData_entrega(formato.format(rsItens.getDate("Data_entrega")));
               AtivRot.setResponsavel(rsItens.getString("Nick"));
               AtivRot.setStatus(rsItens.getString("status"));
               AtivRot.setIdf_responsavel(rsItens.getInt("IDF_Resp"));
               SimpleDateFormat formato2 = new SimpleDateFormat("yyyy-MM-dd");
               AtivRot.setData_entrega_formatada(formato2.format(rsItens.getDate("Data_entrega")));
               AtivRot.setSlide(slideRoteiros.get(rsItens.getInt("cd_slide")));
               rot.addAtivRoteiro(AtivRot);
           }

           rsItens.close();

           stmtItens.close();
       } catch(SQLException e){
           System.err.println("SQLException: " + e.getMessage());
       }
       return rot;
   }

    public ArrayList<Unidade> RetornarDadosUnidade(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<Unidade> unidades = new ArrayList();
        try {
           Statement stmtUnid = conn.createStatement();
           rs = stmtUnid.executeQuery(Query);
            while (rs.next()) {
               Unidade unid = new Unidade();
               unid.setID(rs.getInt("ID"));
               unid.setIdf_projeto(rs.getInt("IDF_Projeto"));
               unid.setNome(rs.getString("Nome"));
               unid.setDescricao(rs.getString("Descricao"));
               unid.setStatus(rs.getString("Status"));
               unid.setDuracao(rs.getString("Duracao"));
               unid.setNmProjeto(rs.getString("NomeProj"));
               unid.setArquivo(rs.getString("Nome_Arquivo"));
               unid.setArquivoRaiz(rs.getString("Arquivo_Raiz"));
               unidades.add(unid);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return unidades;
   }

   @Override
    public ArrayList<TipoAvaliacao> RetornarDadosTipoAvaliacao(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<TipoAvaliacao> tipoAvaliacao = new ArrayList();
        try {
           Statement stmtTp = conn.createStatement();
           rs = stmtTp.executeQuery(Query);
            while (rs.next()) {
               TipoAvaliacao tpAval = new TipoAvaliacao();
               tpAval.setId(rs.getInt("ID"));
               tpAval.setDescricao(rs.getString("Tipo"));
               tipoAvaliacao.add(tpAval);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return tipoAvaliacao;
   }

    public void GravarDadosUnidade(Unidade unid) {
       ResultSet rs;
       String sSql = "";
       int ID = 0;
        try {
           Statement stmtUnid = conn.createStatement();
            sSql = "insert into UNIDADE (Nome, Descricao, Duracao, IDF_Projeto, Status) "
                    + "values ('" + unid.getNome() + "', '" + unid.getDescricao() + "', '" + unid.getDuracao() + "', " + unid.getIdf_projeto() + ", '" + unid.getStatus() + "')";
           stmtUnid.execute(sSql);
           sSql = "select ID from UNIDADE order By ID DESC ";
           rs = stmtUnid.executeQuery(sSql);
            while (rs.next()) {
               ID = rs.getInt("ID");
               break;
           }
            if (ID > 0) {
               //objetivos
               for (int i = 0; i < unid.getArrayObjetivo().size(); ++i) {
                    sSql = "insert into OBJETIVO (DESCRICAO, IDF_UNIDADE) "
                            + "values ('" + unid.getArrayObjetivo().get(i).getDescricao() + "', " + ID + ")";
                   stmtUnid.execute(sSql);
               }

               //conteudos
               for (int i = 0; i < unid.getArrayConteudo().size(); ++i) {
                    sSql = "insert into CONTEUDO (Descricao, IDF_Unidade) "
                            + "values ('" + unid.getArrayConteudo().get(i).getDescricao() + "', " + ID + ")";
                   stmtUnid.execute(sSql);
               }

               //Atividades
               for (int i = 0; i < unid.getArrayAtividade().size(); ++i) {
                    sSql = "insert into ATIVIDADE (Descricao, IDF_Unidade) "
                            + "values ('" + unid.getArrayAtividade().get(i).getDescricao() + "', " + ID + ")";
                   stmtUnid.execute(sSql);
               }

                //Avaliação
               for (int i = 0; i < unid.getArrayAvaliacao().size(); ++i) {
                    sSql = "insert into AVALIACAO (Descricao, IDF_Unidade, IDF_Tipo_Avaliacao) "
                            + "values ('" + unid.getArrayAvaliacao().get(i).getDescricao() + "', " + ID + ", " + RetornarIDFTipoAval(unid.getArrayAvaliacao().get(i).getTipo()) + ")";
                   stmtUnid.execute(sSql);
               }

               String IDF_Usua = "";
                sSql = "select B.IDF_USUARIO from UNIDADE A inner join PROJETO B on B.ID = A.IDF_PROJETO where A.ID = " + ID;
               rs = stmtUnid.executeQuery(sSql);
                while (rs.next()) {
                    IDF_Usua = rs.getString("IDF_Usuario");
                    break;
               }
               /*
               Date data = new Date();
               System.out.println(data.toString());
               ConvDate conDta = new ConvDate();
               String dia_Ini = data.toString().substring(8,10).trim();
               String mes_Ini = data.toString().substring(4,7);
               //String ano_Ini = data.toString().substring(28,32);
               String ano_Ini = data.toString().substring(24,29);
                * */

               SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
               String DataOco = sdf.format(new Date());

               //String DataOco = conDta.RetornarDataFormatada("yyyymmdd", dia_Ini, mes_Ini, ano_Ini, "-");
                sSql = "insert into OCORRENCIA_UNIDADE (IDF_Unidade, IDF_Usuario, Descricao, Data) values "
                        + "(" + ID + ", " + IDF_Usua + ",'Unidade Aberta', '" + DataOco + "')";
               stmtUnid.execute(sSql);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    public void GravarDadosRoteiro(Roteiro rote) {
       ResultSet rs;
        String IDTar = "";
       String sSql = "";
       int ID = 0;
        try {
           Statement stmtRot = conn.createStatement();

           for (int i = 0; i < rote.getArraySlideRot().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
               sSql = "insert into slide (ds_referencia, ds_conteudo, ds_comentario, cd_unidade) "+
                       "values ('"+rote.getArraySlideRot().get(i).getReferencia()+"', '"+rote.getArraySlideRot().get(i).getConteudo()+
                       "', '"+rote.getArraySlideRot().get(i).getComentario()+"', "+rote.getIDF_Unidade()+")";
               stmtRot.execute(sSql);
           }
           //atividades roteiro
           for (int i = 0; i < rote.getArrayAtivRot().size(); ++i) {
               sSql = "insert into ATIVIDADE_ROTEIRO (Titulo, Descricao, Data_Entrega, IDF_Resp, IDF_UNIDADE, Status, cd_slide) "+
                       "values ('"+rote.getArrayAtivRot().get(i).getTitulo()+"', '"+rote.getArrayAtivRot().get(i).getDescricao()+
                       "', '"+rote.getArrayAtivRot().get(i).getData_entrega_formatada()+"', "+rote.getArrayAtivRot().get(i).getIdf_responsavel()+
                       ", "+rote.getArrayAtivRot().get(i).getIdf_unidade()+ ", 'Aberta', "+(rote.getArrayAtivRot().get(i).getSlide() == null ? null : rote.getArrayAtivRot().get(i).getSlide().getId())+")";
               stmtRot.execute(sSql);

               sSql = "select Max(ID) ID from ATIVIDADE_ROTEIRO";
               rs = stmtRot.executeQuery(sSql);
                    while (rs.next()) {
                    IDTar = rs.getString("ID");
               }

           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
           String DataOco = sdf.format(new Date());
/*
           Date data = new Date();
               ConvDate conDta = new ConvDate();
               String dia_Ini = data.toString().substring(8,10).trim();
               String mes_Ini = data.toString().substring(4,7);
               //String ano_Ini = data.toString().substring(28,32);
               String ano_Ini = data.toString().substring(24,29);
               String DataOco = conDta.RetornarDataFormatada("yyyymmdd", dia_Ini, mes_Ini, ano_Ini, "-");
*/
                    sSql = "insert into OCORRENCIA_TAREFA (IDF_Tarefa, IDF_Usuario, Descricao, Data) values "
                            + "(" + IDTar + ", " + rote.getIDF_Usuario() + ",'Tarefa Aberta', '" + DataOco + "')";
               stmtRot.execute(sSql);
           }
        stmtRot.close();

       } catch(SQLException e){
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    public void AlterarDadosRoteiro(Roteiro rote) {
       String sSql = "";
       ResultSet rs = null;
       String IDTar = "";
        try {
           Statement stmtRot = conn.createStatement();

           //tarefas
           for (int i = 0; i < rote.getArraySlideRot().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
               if (rote.getArraySlideRot().get(i).getId() > 0){
                   sSql = "update slide set ds_referencia = '"+rote.getArraySlideRot().get(i).getReferencia()+"',"
                           + " ds_conteudo = '"+rote.getArraySlideRot().get(i).getConteudo()+"', "
                           + "ds_comentario = '"+rote.getArraySlideRot().get(i).getComentario()+"' "
                           + " where cd_slide = "+rote.getArraySlideRot().get(i).getId();
                   stmtRot.execute(sSql);
               }else{//senão insere registro
                   sSql = "insert into slide (ds_referencia, ds_conteudo, ds_comentario, cd_unidade) "+
                           "values ('"+rote.getArraySlideRot().get(i).getReferencia()+"', '"+rote.getArraySlideRot().get(i).getConteudo()+
                           "', '"+rote.getArraySlideRot().get(i).getComentario()+"', "+rote.getIDF_Unidade()+")";
                   stmtRot.execute(sSql);
               }
           }

           for (int i = 0; i < rote.getArrayAtivRot().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
               if (rote.getArrayAtivRot().get(i).getId() > 0){
                   sSql = "update ATIVIDADE_ROTEIRO set titulo = '"+rote.getArrayAtivRot().get(i).getTitulo()+"',"
                           + " descricao = '"+rote.getArrayAtivRot().get(i).getDescricao()+"', "
                           + "IDF_Resp = '"+rote.getArrayAtivRot().get(i).getIdf_responsavel()+"', "
                           + "Data_Entrega = '"+rote.getArrayAtivRot().get(i).getData_entrega_formatada()+"', "
                           + "Status = '"+rote.getArrayAtivRot().get(i).getStatus()+"', "
                           + "cd_slide = "+(rote.getArrayAtivRot().get(i).getSlide() == null ? null : rote.getArrayAtivRot().get(i).getSlide().getId())
                           + " where ID = "+rote.getArrayAtivRot().get(i).getId();
                   stmtRot.execute(sSql);
               }else{//senão insere registro
                   sSql = "insert into ATIVIDADE_ROTEIRO (Titulo, Descricao, Data_Entrega, IDF_Resp, IDF_UNIDADE, Status, cd_slide) "+
                           "values ('"+rote.getArrayAtivRot().get(i).getTitulo()+"', '"+rote.getArrayAtivRot().get(i).getDescricao()+
                           "', '"+rote.getArrayAtivRot().get(i).getData_entrega_formatada()+"', "+rote.getArrayAtivRot().get(i).getIdf_responsavel()+
                           ", "+rote.getIDF_Unidade()+", 'Aberta', "+(rote.getArrayAtivRot().get(i).getSlide() == null ? null : rote.getArrayAtivRot().get(i).getSlide().getId())+")";
                   stmtRot.execute(sSql);

                   sSql = "select Max(ID) ID from ATIVIDADE_ROTEIRO";
                   rs = stmtRot.executeQuery(sSql);
                    while (rs.next()) {
                        IDTar = rs.getString("ID");
                   }
/*
                   Date data = new Date();
                   ConvDate conDta = new ConvDate();
                   System.out.println("HORAS: "+data.toString());
                   //System.out.println("HORAS: "+data.toString().substring(25,28));
                   String dia_Ini = data.toString().substring(8,10).trim();
                   String mes_Ini = data.toString().substring(4,7);
                   //String ano_Ini = data.toString().substring(24,28);
                   String ano_Ini = data.toString().substring(24,29);
                   String DataOco = conDta.RetornarDataFormatada("yyyymmdd", dia_Ini, mes_Ini, ano_Ini, "-");
*/
               SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
               String DataOco = sdf.format(new Date());

                    sSql = "insert into OCORRENCIA_TAREFA (IDF_Tarefa, IDF_Usuario, Descricao, Data) values "
                            + "(" + IDTar + ", " + rote.getIDF_Usuario() + ",'Tarefa Aberta', '" + DataOco + "')";
                   System.out.println(sSql);
                   stmtRot.execute(sSql);
               }
           }
            stmtRot.close();

        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    public void ItensRemovidosRoteiro(ArrayList<Atividade_Roteiro> lstAtividadeRoteiro, ArrayList<Slide> lstSlides){
        String sSql = "";
        try {
           Statement stmtRot = conn.createStatement();
           for (Slide slide: lstSlides) {
               sSql = "delete from slide where cd_slide = "+slide.getId();
               stmtRot.execute(sSql);
           }
           for (Atividade_Roteiro atividadeRoteiro: lstAtividadeRoteiro) {
               sSql = "delete from ATIVIDADE_ROTEIRO where ID = "+atividadeRoteiro.getId();
               stmtRot.execute(sSql);
           }
           stmtRot.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
    }

    private int RetornarIDFTipoAval(String tipo) {
        if (tipo.equals("Testes de múltipla escolha")) {
            return 77;
        } else if (tipo.equals("Testes de verdadeiro/falso")) {
            return 78;
        } else if (tipo.equals("Testes de associação")) {
            return 79;
        } else if (tipo.equals("Testes de preenchimento de lacunas")) {
            return 80;
        } else if (tipo.equals("Testes de arrastar-e-soltar")) {
            return 81;
        } else if (tipo.equals("Puzzles")) {
            return 187;
        } else if (tipo.equals("Questões dissertativas")) {
            return 188;
        } else if (tipo.equals("Questões de resolução de problemas")) {
            return 189;
        } else if (tipo.equals("Rubricas")) {
            return 190;
        } else if (tipo.equals("Portfólios")) {
            return 191;
        } else if (tipo.equals("Auto-avaliação")) {
            return 192;
        } else {
            return 193;
   }
    }

    public void AlterarDadosUnidade(Unidade unid) {
       String sSql = "";
        try {
           Statement stmtUnid = conn.createStatement();
            sSql = "update UNIDADE set nome = '" + unid.getNome() + "', descricao = '" + unid.getDescricao()
                    + "', duracao = '" + unid.getDuracao() + "', Status = '" + unid.getStatus() + "' where ID = " + unid.getId();
           stmtUnid.execute(sSql);

           //objetivos
           for (int i = 0; i < unid.getArrayObjetivo().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
                if (unid.getArrayObjetivo().get(i).getId() > 0) {
                    sSql = "update OBJETIVO set descricao = '" + unid.getArrayObjetivo().get(i).getDescricao() + "' where ID = " + unid.getArrayObjetivo().get(i).getId();
                   stmtUnid.execute(sSql);
                } else {//senão insere registro
                    sSql = "insert into OBJETIVO (descricao, IDF_Unidade) values ('" + unid.getArrayObjetivo().get(i).getDescricao() + "', " + unid.getId() + " )";
                   stmtUnid.execute(sSql);
               }
           }

           //conteudos
           for (int i = 0; i < unid.getArrayConteudo().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
                if (unid.getArrayConteudo().get(i).getId() > 0) {
                    sSql = "update CONTEUDO set descricao = '" + unid.getArrayConteudo().get(i).getDescricao() + "' where ID = " + unid.getArrayConteudo().get(i).getId();
                   stmtUnid.execute(sSql);
                } else {//senão insere registro
                    sSql = "insert into CONTEUDO (descricao, IDF_Unidade) values ('" + unid.getArrayConteudo().get(i).getDescricao() + "', " + unid.getId() + " )";
                   stmtUnid.execute(sSql);
               }
           }

           //atividades
           for (int i = 0; i < unid.getArrayAtividade().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
                if (unid.getArrayAtividade().get(i).getId() > 0) {
                    sSql = "update ATIVIDADE set descricao = '" + unid.getArrayAtividade().get(i).getDescricao() + "' where ID = " + unid.getArrayAtividade().get(i).getId();
                   stmtUnid.execute(sSql);
                } else {//senão insere registro
                    sSql = "insert into ATIVIDADE (descricao, IDF_Unidade) values ('" + unid.getArrayAtividade().get(i).getDescricao() + "', " + unid.getId() + " )";
                   stmtUnid.execute(sSql);
               }
           }

           //avaliacao
           for (int i = 0; i < unid.getArrayAvaliacao().size(); ++i) {
               //se encontrar ID entao esta em estado de edicao(faz update)
                if (unid.getArrayAvaliacao().get(i).getId() > 0) {
                    sSql = "update AVALIACAO set descricao = '" + unid.getArrayAvaliacao().get(i).getDescricao() + "', "
                            + "IDF_Tipo_Avaliacao = '" + RetornarIDFTipoAval(unid.getArrayAvaliacao().get(i).getTipo().trim()) + "', "
                            + "where ID = " + unid.getArrayAvaliacao().get(i).getId();
                   stmtUnid.execute(sSql);
                } else {//senão insere registro
                    sSql = "insert into AVALIACAO (descricao, IDF_Tipo_Avaliacao, IDF_Unidade) values ('" + unid.getArrayAvaliacao().get(i).getDescricao() + "', "
                            + RetornarIDFTipoAval(unid.getArrayAvaliacao().get(i).getTipo().trim()) + ", " + unid.getId() + " )";
                   stmtUnid.execute(sSql);
               }
           }

        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    public void ExcluirDadosUnidade(Unidade unid) {
       String sSql = "";
        try {
           Statement stmt = conn.createStatement();
            sSql = "delete from OCORRENCIA_UNIDADE where IDF_Unidade = " + unid.getId();
           stmt.execute(sSql);

           sSql = "delete from slide where cd_unidade = "+unid.getId();
           stmt.execute(sSql);

           sSql = "delete from atividade_roteiro where IDF_Unidade = "+unid.getId();
           stmt.execute(sSql);

           //Objetivo
            sSql = "delete from OBJETIVO where IDF_Unidade = " + unid.getId();
           stmt.execute(sSql);

           //Conteudo
            sSql = "delete from CONTEUDO where IDF_Unidade = " + unid.getId();
           stmt.execute(sSql);

           //Atividade
            sSql = "delete from ATIVIDADE where IDF_Unidade = " + unid.getId();
           stmt.execute(sSql);

           //Avaliacao
            sSql = "delete from AVALIACAO where IDF_Unidade = " + unid.getId();
           stmt.execute(sSql);

           //Unidade
            sSql = "delete from UNIDADE where ID = " + unid.getId();
           stmt.execute(sSql);

        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
   }

    //Método implementado para retornar Dados das tarefas...
    @Override
    public ArrayList<Atividade_Roteiro> RetornarDadosTarefa(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<Atividade_Roteiro> tarefas = new ArrayList();
        try {
           Statement stmtTar = conn.createStatement();
           rs = stmtTar.executeQuery(Query);
            while (rs.next()) {
               Atividade_Roteiro tar = new Atividade_Roteiro();
               tar.setId(rs.getInt("ID"));
               tar.setTitulo(rs.getString("Titulo"));
               tar.setDescricao(rs.getString("Descricao"));
               tar.setResponsavel(rs.getString("Nick"));
               SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
               tar.setData_entrega(formato.format(rs.getDate("Data_entrega")));
               tar.setStatus(rs.getString("Status"));
               tar.setNm_unidade(rs.getString("NmUnidade"));
               tar.setIdf_unidade(rs.getInt("IDF_Unidade"));
               tar.setNm_projeto(rs.getString("NmProjeto"));
               tar.setIdf_responsavel(rs.getInt("IDF_Resp"));
               SimpleDateFormat formato2 = new SimpleDateFormat("yyyy-MM-dd");
               tar.setData_entrega_formatada(formato2.format(rs.getDate("Data_entrega")));

               tarefas.add(tar);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return tarefas;
   }

    //Método implementado para retornar Dados das tarefas...
    public ArrayList<OcorrenciaTarefa> RetornarDadosOcoTarefa(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<OcorrenciaTarefa> Ocotarefas = new ArrayList();
        try {
           Statement stmt = conn.createStatement();
           rs = stmt.executeQuery(Query);
            while (rs.next()) {
               OcorrenciaTarefa oco = new OcorrenciaTarefa();
               oco.setID(rs.getInt("ID"));
               oco.setDescricao(rs.getString("Descricao"));
               oco.setObservacao(rs.getString("Observacao"));
               SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
               oco.setData(formato.format(rs.getDate("Data")));
               oco.setUsuario(rs.getString("Nick"));
               oco.setIDF_Tarefa(rs.getInt("IDF_Tarefa"));

               Ocotarefas.add(oco);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return Ocotarefas;
   }

    //Método implementado para retornar Dados das tarefas...
    public ArrayList<Objetivo> RetornarDadosObjetivos(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<Objetivo> objetivos = new ArrayList();
        try {
           Statement stmtObj = conn.createStatement();
           rs = stmtObj.executeQuery(Query);
            while (rs.next()) {
               Objetivo Obj = new Objetivo();
               Obj.setId(rs.getInt("ID"));
               Obj.setDescricao(rs.getString("Descricao"));
               Obj.setIdf_unidade(rs.getInt("IDF_Unidade"));

               objetivos.add(Obj);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return objetivos;
   }

   @Override
    public ArrayList<Unidade> RetornarDadosUnidadeConcluidas(String Query) {
       Query = Query.toUpperCase();
       ResultSet rsUnidade = null;
       ResultSet rsTarefas = null;
       String sSQL = "";
       boolean bIncluir = false;
       ArrayList<Unidade> unidades = new ArrayList();
        try {
           Statement stmtUnid = conn.createStatement();
           Statement stmtTar = conn.createStatement();
            sSQL = "select A.ID, A.Nome, A.Descricao, A.IDF_Projeto, "
                    + "A.Status, A.Duracao, A.Arquivo_Raiz, B.Nome NomeProj "
                    + "from UNIDADE A "
                    + "inner join Projeto B on B.ID = A.IDF_Projeto "
                    + "where A.Status = 'Em Andamento' ";

           rsUnidade = stmtUnid.executeQuery(sSQL);
           while (rsUnidade.next()){
               sSQL = "select * from ATIVIDADE_ROTEIRO A "+
                       "where A.IDF_Unidade = "+rsUnidade.getString("ID");
               rsTarefas = stmtTar.executeQuery(sSQL);
               bIncluir = true;
                while (rsTarefas.next()) {
                    if (!rsTarefas.getString("Status").equals("Concluída")) {
                       bIncluir = false;
               }
                }

                if (bIncluir) {
                    Unidade unid = new Unidade();
                    unid.setID(rsUnidade.getInt("ID"));
                    unid.setIdf_projeto(rsUnidade.getInt("IDF_Projeto"));
                    unid.setNome(rsUnidade.getString("Nome"));
                    unid.setDescricao(rsUnidade.getString("Descricao"));
                    unid.setStatus(rsUnidade.getString("Status"));
                    unid.setDuracao(rsUnidade.getString("Duracao"));
                    unid.setNmProjeto(rsUnidade.getString("NomeProj"));
                    unid.setArquivoRaiz(rsUnidade.getString("Arquivo_Raiz"));
                    unidades.add(unid);
               }
           }

           rsUnidade.close();
           rsTarefas.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return unidades;
   }

    @Override
    public ArrayList<OcorrenciaUnidade> RetornarDadosOcoUnidade(String Query) {
       Query = Query.toUpperCase();
       ResultSet rs = null;
       ArrayList<OcorrenciaUnidade> OcoUnidade = new ArrayList();
        try {
           Statement stmt = conn.createStatement();
           rs = stmt.executeQuery(Query);
            while (rs.next()) {
               OcorrenciaUnidade oco = new OcorrenciaUnidade();
               oco.setID(rs.getInt("ID"));
               oco.setDescricao(rs.getString("Descricao"));
               oco.setObservacao(rs.getString("Observacao"));
               SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
               oco.setData(formato.format(rs.getDate("Data")));
               oco.setUsuario(rs.getString("Nick"));
               oco.setIDF_Unidade(rs.getInt("IDF_Unidade"));

               OcoUnidade.add(oco);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return OcoUnidade;
   }

   @Override
   public boolean GerarUnidadeSCORM(String arquivo, String nomeProj,
            String nomeUnid, String nomeArqRaiz) {
        // Cria o diretório caso ele não exista
        File diretorio = new File("c:/Uploads/SCORM");
        if (!diretorio.exists()) {
          diretorio.mkdir();
        }

        ContentPackageBuilder content = new ContentPackageBuilder("c:/Uploads/SCORM");
        content.add(new File(arquivo), nomeUnid, nomeArqRaiz);
        try {
            content.build(nomeProj, diretorio + "//" + nomeProj + ".zip");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
   }

   public void adicionarTemplateSlide(Slide template){
       try {
           Statement stmtRot = conn.createStatement();
           String sSql = "insert into template_slide (ds_referencia, ds_conteudo) "+
                       "values ('"+template.getReferencia()+"', '"+template.getConteudo()+"')";
           stmtRot.execute(sSql);
           stmtRot.close();
       } catch(SQLException e){
           System.err.println("SQLException: " + e.getMessage());
       }
   }

   public boolean removerTemplateSlide(Slide template){
        String sSql = "";
        try {
           Statement stmt = conn.createStatement();
            sSql = "delete from template_slide where cd_template_slide = " + template.getId();
           stmt.execute(sSql);
           stmt.close();
           return true;
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
           return false;
       }
   }

   public ArrayList<Slide> getListaTemplateSlide(){
       ResultSet rs = null;
       ArrayList<Slide> lstTemplate = new ArrayList<Slide>();
        try {
           Statement stmt = conn.createStatement();
           rs = stmt.executeQuery("select * from template_slide");
            while (rs.next()) {
               Slide template = new Slide();
               template.setId(rs.getInt("cd_template_slide"));
               template.setReferencia(rs.getString("ds_referencia"));
               template.setConteudo(rs.getString("ds_conteudo"));
               lstTemplate.add(template);
           }
           rs.close();
        } catch (SQLException e) {
           System.err.println("SQLException: " + e.getMessage());
       }
       return lstTemplate;
   }
}